home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 2000 August: Tool Chest / Dev.CD Aug 00 TC Disk 1.toast / pc / sample code / contributed / spriteworld / examples / spritetest / application.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-06-23  |  15.4 KB  |  949 lines
  1. ///--------------------------------------------------------------------------------------
  2. //    Application.c
  3. //
  4. //    Created:    Sunday, April 11, 1993
  5. //    By:            Tony Myles
  6. //
  7. //    Copyright: © 1993-94 Tony Myles, All rights reserved worldwide.
  8. ///--------------------------------------------------------------------------------------
  9.  
  10.  
  11. #if THINK_C
  12. #ifndef __BDC__
  13. #include <BDC.h>
  14. #endif
  15. #else
  16. #ifndef __PACKAGES__
  17. #include <Packages.h>
  18. #endif
  19. #endif
  20.  
  21. #ifndef __APPLEEVENTS__
  22. #include <AppleEvents.h>
  23. #endif
  24.  
  25. #ifndef __OSUTILS__
  26. #include <OSUtils.h>
  27. #endif
  28.  
  29. #ifndef __DESK__
  30. #include <Desk.h>
  31. #endif
  32.  
  33. #ifndef __DIALOGS__
  34. #include <Dialogs.h>
  35. #endif
  36.  
  37. #ifndef __DISKINIT__
  38. #include <DiskInit.h>
  39. #endif
  40.  
  41. #ifndef __EPPC__
  42. #include <EPPC.h>
  43. #endif
  44.  
  45. #ifndef __EVENTS__
  46. #include <Events.h>
  47. #endif
  48.  
  49. #ifndef __ERRORS__
  50. #include <Errors.h>
  51. #endif
  52.  
  53. #ifndef __FONTS__
  54. #include <Fonts.h>
  55. #endif
  56.  
  57. #ifndef __GESTALTEQU__
  58. #include <GestaltEqu.h>
  59. #endif
  60.  
  61. #ifndef __MENUS__
  62. #include <Menus.h>
  63. #endif
  64.  
  65. #ifndef __RESOURCES__
  66. #include <Resources.h>
  67. #endif
  68.  
  69. #ifndef __OSEVENTS__
  70. #include <OSEvents.h>
  71. #endif
  72.  
  73. #ifndef __TEXTEDIT__
  74. #include <TextEdit.h>
  75. #endif
  76.  
  77. #ifndef __TRAPS__
  78. #include <Traps.h>
  79. #endif
  80.  
  81. #ifndef __TOOLUTILS__
  82. #include <ToolUtils.h>
  83. #endif
  84.  
  85. #ifndef __WINDOWS__
  86. #include <Windows.h>
  87. #endif
  88.  
  89. #ifndef __SPRITEWORLD__
  90. #include "SpriteWorld.h"
  91. #endif
  92.  
  93. #ifndef __SPRITEWORLDUTILS__
  94. #include "SpriteWorldUtils.h"
  95. #endif
  96.  
  97. #ifndef __APPLICATION__
  98. #include "Application.h"
  99. #endif
  100.  
  101. #ifndef __SPRITETEST__
  102. #include "SpriteTest.h"
  103. #endif
  104.  
  105. #ifndef __ABOUT__
  106. #include "About.h"
  107. #endif
  108.  
  109.  
  110. Boolean gIsRunning = true;
  111. Boolean gInBackGround = false;
  112. Boolean gHasWaitNextEvent = false;
  113. WindowPtr gWindowP = NULL;
  114. SpriteTestPtr gSpriteTestP = NULL;
  115.  
  116.  
  117. void main(void)
  118. {
  119.     OSErr err = noErr;
  120.  
  121.     if (Initialize(kNumberOfMoreMastersCalls))
  122.     {
  123.         if (CheckSystem() && CheckMemory())
  124.         {
  125.             if (HasAppleEvents())
  126.             {
  127.                 err = InstallAppleEventHandlers();
  128.     
  129.                 if (err != noErr)
  130.                 {
  131.                     ErrorAlert(err, kUnknownErrorStringIndex);
  132.                 }
  133.             }
  134.     
  135.             CreateMenuBar();
  136.             CreateWindow();
  137.     
  138.             if (EnterApplication())
  139.             {
  140.                 ServiceEvents();
  141.             }
  142.     
  143.             ExitApplication();
  144.         }
  145.     }
  146.  
  147.     ExitToShell();
  148. }
  149.  
  150.  
  151. Boolean Initialize(
  152.     short numberOfMasters)
  153. {
  154.     OSErr err = noErr;
  155.     EventRecord tempEvent;
  156.  
  157.     if (kStackNeeded > StackSpace())
  158.     {
  159.             // new address is heap size + current stack - needed stack
  160.         SetApplLimit((Ptr)((long)GetApplLimit() - kStackNeeded + StackSpace()));
  161.  
  162.         err = MemError();
  163.     }
  164.  
  165.     if (err == noErr)
  166.     {
  167.         MaxApplZone();
  168.  
  169.         while ((err == noErr) && (numberOfMasters--))
  170.         {
  171.             MoreMasters();
  172.  
  173.             err = MemError();
  174.         }
  175.     }
  176.  
  177.     if (err == noErr)
  178.     {
  179.         InitGraf(&qd.thePort);
  180.         InitFonts();
  181.         InitWindows();
  182.         InitMenus();
  183.         TEInit();
  184.         InitDialogs(NULL);
  185.         InitCursor();
  186.         FlushEvents(everyEvent, 0);
  187.  
  188.         (void)EventAvail(everyEvent, &tempEvent);
  189.         (void)EventAvail(everyEvent, &tempEvent);
  190.         (void)EventAvail(everyEvent, &tempEvent);
  191.  
  192.         gHasWaitNextEvent = HasWaitNextEvent();
  193.     }
  194.  
  195.         // if we get an error here, we can’t do jack
  196.         // don’t even TRY to put up an alert
  197.  
  198.     return err == noErr;
  199. }
  200.  
  201.  
  202. Boolean CheckSystem(void)
  203. {
  204.     OSErr    err;
  205.     Boolean isSystemGood = true;
  206.     long    gestaltResult;
  207.  
  208.     err = Gestalt(gestaltTimeMgrVersion, &gestaltResult);
  209.  
  210.     isSystemGood = (err == noErr) && (gestaltResult >= gestaltStandardTimeMgr);
  211.  
  212.     if (!isSystemGood)
  213.     {
  214.         CantRunOnThisMachine();
  215.     }
  216.  
  217.     return isSystemGood;
  218. }
  219.  
  220.  
  221. Boolean CheckMemory(void)
  222. {
  223.     Boolean isEnoughMemory;
  224.     long heapNeeded, heapSize;
  225.     GDHandle mainGDeviceH;
  226.     Rect worldRect;
  227.     short pixelSize;
  228.  
  229.     if (SWHasColorQuickDraw())
  230.     {
  231.         mainGDeviceH = GetMainDevice();
  232.  
  233.         worldRect = (**mainGDeviceH).gdRect;
  234.         pixelSize = (**(**mainGDeviceH).gdPMap).pixelSize;
  235.     }
  236.     else
  237.     {
  238.         worldRect = qd.screenBits.bounds;
  239.         pixelSize = 1;
  240.     }
  241.  
  242.     heapNeeded = 3 * ((((worldRect.right - worldRect.left) *
  243.                             (worldRect.bottom - worldRect.top)) * pixelSize) / 8);
  244.     heapNeeded += 100000;
  245.  
  246.     heapSize = (long)GetApplLimit() - (long)ApplicZone();
  247.  
  248.     isEnoughMemory = (heapSize > heapNeeded);
  249.  
  250.     if (!isEnoughMemory)
  251.     {
  252.         ErrorAlert(memFullErr, kNotEnoughMemoryStringIndex);
  253.     }
  254.  
  255.     return isEnoughMemory;
  256. }
  257.  
  258.  
  259. Boolean HasAppleEvents(void)
  260. {
  261.     Boolean hasAppleEvents;
  262.     OSErr err;
  263.     long gestaltResult;
  264.  
  265.     err = Gestalt(gestaltAppleEventsAttr, &gestaltResult);
  266.  
  267.     if (err == noErr)
  268.     {
  269.         hasAppleEvents = (gestaltResult & (1 << gestaltAppleEventsPresent)) != 0;
  270.     }
  271.     else
  272.     {
  273.         hasAppleEvents = false;
  274.     }
  275.  
  276.     return hasAppleEvents;
  277. }
  278.  
  279.  
  280. #ifndef NewAEEventHandlerProc
  281. #define NewAEEventHandlerProc(x) ((EventHandlerProcPtr)x)
  282. #endif 
  283.  
  284. OSErr InstallAppleEventHandlers(void)
  285. {
  286.     OSErr err = noErr;
  287.  
  288.     err = AEInstallEventHandler(kCoreEventClass, kAEOpenApplication, NewAEEventHandlerProc(HandleOpenApp), 0, false);
  289.  
  290.     if (err == noErr)
  291.     {
  292.         err = AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments, NewAEEventHandlerProc(HandleOpenDoc), 0, false);
  293.     }
  294.  
  295.     if (err == noErr)
  296.     {
  297.         err = AEInstallEventHandler(kCoreEventClass, kAEPrintDocuments, NewAEEventHandlerProc(HandlePrintDoc), 0, false);
  298.     }
  299.  
  300.     if (err == noErr)
  301.     {
  302.         err = AEInstallEventHandler(kCoreEventClass, kAEQuitApplication, NewAEEventHandlerProc(HandleQuit), 0, false);
  303.     }
  304.  
  305.     return err;
  306. }
  307.  
  308.  
  309. void CreateMenuBar(void)
  310. {
  311.     Handle menuBarH;
  312.  
  313.     menuBarH = GetNewMBar(kMenuBarResID);
  314.  
  315.     if (menuBarH != NULL)
  316.     {
  317.         SetMenuBar(menuBarH);
  318.         AddResMenu(GetMHandle(kAppleMenuID), 'DRVR');
  319.         DrawMenuBar();
  320.     }
  321.     else
  322.     {
  323.         CantFindResource();
  324.     }
  325. }
  326.  
  327.  
  328. void CreateWindow(void)
  329. {
  330.     gWindowP = SWHasColorQuickDraw() ?
  331.             GetNewCWindow(kWindowResID, NULL, (WindowPtr)-1L) :
  332.             GetNewWindow(kWindowResID, NULL, (WindowPtr)-1L);
  333.  
  334.     if (gWindowP != NULL)
  335.     {
  336.         SizeWindow(gWindowP, qd.screenBits.bounds.right, qd.screenBits.bounds.bottom, false);
  337.         MoveWindow(gWindowP, 0, 0, false);
  338.     }
  339.     else
  340.     {
  341.         CantFindResource();
  342.     }
  343. }
  344.  
  345.  
  346. Boolean EnterApplication(void)
  347. {
  348.     OSErr    err;
  349.  
  350.     err = SWEnterSpriteWorld();
  351.  
  352.     if (err == noErr)
  353.     {
  354.         err = CreateSpriteTest(&gSpriteTestP, (CWindowPtr)gWindowP);
  355.     }
  356.  
  357.     if (err == noErr)
  358.     {
  359.         ShowWindow(gWindowP);
  360.         UpdateSpriteTest(gSpriteTestP);
  361.         ValidRect(&gWindowP->portRect);
  362.     }
  363.  
  364.     if (err != noErr)
  365.     {
  366.         ErrorAlert(err, kUnknownErrorStringIndex);
  367.     }
  368.  
  369.     return err == noErr;
  370. }
  371.  
  372.  
  373. void ExitApplication(void)
  374. {
  375.     DisposeSpriteTest(gSpriteTestP);
  376.  
  377.     SWExitSpriteWorld();
  378.  
  379.     DisposeWindow(gWindowP);
  380. }
  381.  
  382.  
  383. void ServiceEvents(void)
  384. {
  385.     Boolean haveEvent;
  386.     EventRecord event;
  387.     long sleepTime;
  388.     RgnHandle mouseRgn = gHasWaitNextEvent ? NewRgn() : NULL;
  389.  
  390.     while (gIsRunning)
  391.     {
  392.         if (gHasWaitNextEvent)
  393.         {
  394.             sleepTime = gInBackGround ? kBackGroundSleepTime : kForeGroundSleepTime;
  395.  
  396.             haveEvent = WaitNextEvent(everyEvent, &event, sleepTime, mouseRgn);
  397.         }
  398.         else
  399.         {
  400.             SystemTask();
  401.             haveEvent = GetNextEvent(everyEvent, &event);
  402.         }
  403.  
  404.         if (haveEvent)
  405.         {
  406.             DispatchEvent(&event);
  407.         }
  408.         else
  409.         {
  410.             HandleNullEvent();
  411.         }
  412.     }
  413.  
  414.     if (mouseRgn != NULL)
  415.     {
  416.         DisposeRgn(mouseRgn);
  417.     }
  418. }
  419.  
  420.  
  421. void DispatchEvent(
  422.     EventRecord* event)
  423. {
  424.     switch(event->what)
  425.     {
  426.         case mouseDown:
  427.             HandleMouseEvent(event);
  428.             break;
  429.         case mouseUp:
  430.             break;
  431.         case keyUp:
  432.             break;
  433.         case keyDown:
  434.         case autoKey:
  435.             HandleKeyEvent((char)(event->message & charCodeMask), event->modifiers);
  436.             break;
  437.         case updateEvt:
  438.             HandleUpdateEvent((WindowPtr)event->message);
  439.             break;
  440.         case diskEvt:
  441.             HandleDiskEvent(event->message);
  442.             break;
  443.         case activateEvt:
  444.             HandleActivateEvent((WindowPtr)event->message);
  445.             break;
  446.         case networkEvt:
  447.             break;
  448.         case driverEvt:
  449.             break;
  450.         case app1Evt:
  451.             break;
  452.         case app2Evt:
  453.             break;
  454.         case app3Evt:
  455.             break;
  456.         case osEvt:
  457.             HandleOSEvent(event->message);
  458.             break;
  459.         case kHighLevelEvent:
  460.             AEProcessAppleEvent(event);
  461.             break;
  462.         default:
  463.         break;
  464.     }
  465. }
  466.  
  467.  
  468. void HandleMouseEvent(
  469.     EventRecord* event)
  470. {
  471.     WindowPtr whichWindow;
  472.     short partCode;
  473.  
  474.     partCode = FindWindow(event->where, &whichWindow);
  475.  
  476.     switch (partCode)
  477.     {
  478.         case inDesk:        
  479.             break;
  480.         case inMenuBar:
  481.             AdjustMenuItems();
  482.             HandleMenuCommand(MenuSelect(event->where));
  483.             break;
  484.         case inSysWindow:
  485.             SystemClick(event, whichWindow);
  486.             break;
  487.         case inContent:
  488.             break;
  489.         case inDrag:
  490.             break;
  491.         case inGrow:
  492.             break;
  493.         case inGoAway:
  494.             break;
  495.         case inZoomIn:
  496.         case inZoomOut:
  497.             break;
  498.         default:            
  499.             break;
  500.     }
  501. }
  502.  
  503.  
  504. void HandleKeyEvent(
  505.     char key,
  506.     short modifiers)
  507. {
  508.     if ((modifiers & cmdKey) != 0)
  509.     {
  510.         AdjustMenuItems();
  511.         HandleMenuCommand(MenuKey(key));
  512.     }
  513.     else
  514.     {
  515.             // if the spacebar is hit, fill the screen with black
  516.             // useful for debugging purposes
  517.         if (key == ' ')
  518.         {
  519.             #if dangerousPattern
  520.             FillRect(&gWindowP->portRect, qd.black);
  521.             #else
  522.             FillRect(&gWindowP->portRect, &qd.black);
  523.             #endif
  524.         }
  525.     }
  526. }
  527.  
  528.  
  529. void HandleUpdateEvent(
  530.     WindowPtr updateWindowP)
  531. {
  532.     if (updateWindowP == gWindowP)
  533.     {
  534.         SetPort(updateWindowP);
  535.         BeginUpdate(updateWindowP);
  536.  
  537.         UpdateSpriteTest(gSpriteTestP);
  538.  
  539.         EndUpdate(updateWindowP);
  540.     }
  541. }
  542.  
  543.  
  544. void HandleActivateEvent(
  545.     WindowPtr updateWindowP)
  546. {
  547. #if MPW
  548. #pragma unused(updateWindowP)
  549. #endif
  550. }
  551.  
  552.  
  553. void HandleOSEvent(
  554.     long message)
  555. {
  556.     if ((message >> 24) == suspendResumeMessage)
  557.     {
  558.         if ((message & resumeFlag) != 0)
  559.         {
  560.             gInBackGround = false;
  561.         }
  562.         else
  563.         {
  564.             gInBackGround = true;
  565.         }
  566.     }
  567. }
  568.  
  569.  
  570. void HandleDiskEvent(
  571.     long message)
  572. {
  573.     OSErr err;
  574.     Point dialogLocation = {100, 100};
  575.  
  576.     if ((message & 0xFFFF0000) != noErr)
  577.     {
  578.         err = DIBadMount(dialogLocation, message);
  579.  
  580.         if (err != noErr)
  581.         {
  582.             ErrorAlert(err, kUnknownErrorStringIndex);
  583.         }
  584.     }
  585. }
  586.  
  587.  
  588. void HandleNullEvent(void)
  589. {
  590.     RunSpriteTest(gSpriteTestP);
  591. }
  592.  
  593.  
  594. void HandleMenuCommand(
  595.     long menuItemIdentifier)
  596. {
  597.     short menuIdent = HiWord(menuItemIdentifier);
  598.     short menuItem = LoWord(menuItemIdentifier);
  599.  
  600.     switch (menuIdent)
  601.     {
  602.         case kAppleMenuID:
  603.         {
  604.             HandleAppleMenuCommand(menuItem);
  605.             break;
  606.         }
  607.  
  608.         case kFileMenuID:
  609.         {
  610.             HandleFileMenuCommand(menuItem);
  611.             break;
  612.         }
  613.  
  614.         case kEditMenuID:
  615.         {
  616.             HandleEditMenuCommand(menuItem);
  617.             break;
  618.         }
  619.  
  620.         case kSpriteMenuID:
  621.         {
  622.             HandleSpriteMenuCommand(menuItem);
  623.             break;
  624.         }
  625.  
  626.         case kTestMenuID:
  627.         {
  628.             HandleTestMenuCommand(menuItem);
  629.             break;
  630.         }
  631.     }
  632.  
  633.     HiliteMenu(0);
  634. }
  635.  
  636.  
  637. void HandleAppleMenuCommand(
  638.     short menuItem)
  639. {
  640.     Str255 deskAccName;
  641.  
  642.     switch (menuItem)
  643.     {
  644.         case kAboutItem:
  645.         {
  646.             DisplayAboutBox();
  647.             break;
  648.         }
  649.  
  650.         default:
  651.         {
  652.             GetItem(GetMHandle(kAppleMenuID), menuItem, deskAccName);
  653.             OpenDeskAcc(deskAccName);
  654.             break;
  655.         }
  656.     }
  657. }
  658.  
  659.  
  660. void HandleFileMenuCommand(
  661.     short menuItem)
  662. {
  663.     switch (menuItem)
  664.     {
  665.         case kQuitItem:
  666.         {
  667.             gIsRunning = false;
  668.             break;
  669.         }
  670.     }
  671. }
  672.  
  673.  
  674. void HandleEditMenuCommand(
  675.     short menuItem)
  676. {
  677.     (void)SystemEdit(menuItem);
  678. }
  679.  
  680.  
  681. void HandleSpriteMenuCommand(
  682.     short menuItem)
  683. {
  684.     switch (menuItem)
  685.     {
  686.         case kCreateSpriteItem:
  687.         {
  688.             HandleCreateSpriteCommand(gSpriteTestP);
  689.             break;
  690.         }
  691.  
  692.         case kCompileSpriteItem:
  693.         {
  694.             CompileSpriteCommand(gSpriteTestP);
  695.             break;
  696.         }
  697.  
  698.         case kHideTitleItem:
  699.         {
  700.             HandleSpriteTestTitleCommand(gSpriteTestP);
  701.             break;
  702.         }
  703.  
  704.         case kHideBallsItem:
  705.         {
  706.             HandleBouncingBallsCommand(gSpriteTestP);
  707.             break;
  708.         }
  709.  
  710.     }
  711. }
  712.  
  713.  
  714. void HandleTestMenuCommand(
  715.     short menuItem)
  716. {
  717.     switch (menuItem)
  718.     {
  719.         case kTestItem:
  720.         {
  721.             if (gSpriteTestP->isCommandActive[kCopyBitsTestCommand])
  722.                 CopyBitsSpeedTestCommand(gSpriteTestP);
  723.             else if (gSpriteTestP->isCommandActive[kBlitPixieTestCommand])
  724.                 BlitPixieSpeedTestCommand(gSpriteTestP);
  725.             else
  726.                 RunCompiledSpriteCommand(gSpriteTestP, false);
  727.             break;
  728.         }
  729.  
  730.         case kCopyBitsTestItem:
  731.         {
  732.             gSpriteTestP->isCommandActive[kCopyBitsTestCommand] = true;
  733.             gSpriteTestP->isCommandActive[kBlitPixieTestCommand] = false;
  734.             gSpriteTestP->isCommandActive[kRunCompiledSpriteCommand] = false;
  735.             break;
  736.         }
  737.  
  738.         case kBlitPixieTestItem:
  739.         {
  740.             gSpriteTestP->isCommandActive[kCopyBitsTestCommand] = false;
  741.             gSpriteTestP->isCommandActive[kBlitPixieTestCommand] = true;
  742.             gSpriteTestP->isCommandActive[kRunCompiledSpriteCommand] = false;
  743.             break;
  744.         }
  745.  
  746.         case kRunCompiledSpriteItem:
  747.         {
  748.             gSpriteTestP->isCommandActive[kCopyBitsTestCommand] = false;
  749.             gSpriteTestP->isCommandActive[kBlitPixieTestCommand] = false;
  750.             gSpriteTestP->isCommandActive[kRunCompiledSpriteCommand] = true;
  751.             break;
  752.         }
  753.  
  754.         case kCollisionDetectionItem:
  755.         {
  756.             gSpriteTestP->isCommandActive[kCollisionDetectionCommand] =
  757.                     !gSpriteTestP->isCommandActive[kCollisionDetectionCommand];
  758.             break;
  759.         }
  760.     }
  761. }
  762.  
  763.  
  764. void AdjustMenuItems(void)
  765. {
  766.     MenuHandle tempMenuH;
  767.  
  768.         // adjust the test menu
  769.     tempMenuH = GetMHandle(kSpriteMenuID);
  770.  
  771.     CheckItem(tempMenuH, kHideTitleItem, gSpriteTestP->isCommandActive[kSpriteTestTitleCommand]);
  772.     CheckItem(tempMenuH, kHideBallsItem, gSpriteTestP->isCommandActive[kBouncingBallsCommand]);
  773.  
  774.         // adjust the sprite menu
  775.     tempMenuH = GetMHandle(kTestMenuID);
  776.  
  777.     CheckItem(tempMenuH, kCopyBitsTestItem, gSpriteTestP->isCommandActive[kCopyBitsTestCommand]);
  778.     CheckItem(tempMenuH, kBlitPixieTestItem, gSpriteTestP->isCommandActive[kBlitPixieTestCommand]);
  779.     CheckItem(tempMenuH, kRunCompiledSpriteItem, gSpriteTestP->isCommandActive[kRunCompiledSpriteCommand]);
  780.     CheckItem(tempMenuH, kCollisionDetectionItem, gSpriteTestP->isCommandActive[kCollisionDetectionCommand]);
  781.  
  782.     if ((!SWHasColorQuickDraw()) ||
  783.         ((**gSpriteTestP->spriteWorldP->backFrameP->framePort.colorGrafP->portPixMap).pixelSize != 8))
  784.     {
  785.             // disable some of the tests if we are not in 8 bit
  786.         DisableItem(tempMenuH, kBlitPixieTestItem);
  787.         DisableItem(tempMenuH, kRunCompiledSpriteItem);
  788.     }
  789.  
  790. #if defined(powerc) || defined(__powerc)
  791.     DisableItem(tempMenuH, kRunCompiledSpriteItem);
  792. #endif
  793. }
  794.  
  795.  
  796. pascal OSErr HandleOpenApp(
  797.     AppleEvent srcAppleEvent,
  798.     AppleEvent replyAppleEvent,
  799.     long refCon)
  800. {
  801. #if MPW
  802. #pragma unused(srcAppleEvent,replyAppleEvent,refCon)
  803. #endif
  804.  
  805.     return noErr;
  806. }
  807.  
  808.  
  809. pascal OSErr HandleOpenDoc(
  810.     AppleEvent srcAppleEvent,
  811.     AppleEvent replyAppleEvent,
  812.     long refCon)
  813. {
  814. #if MPW
  815. #pragma unused(srcAppleEvent,replyAppleEvent,refCon)
  816. #endif
  817.     return errAEEventNotHandled;
  818. }
  819.  
  820.  
  821. pascal OSErr HandlePrintDoc(
  822.     AppleEvent srcAppleEvent,
  823.     AppleEvent replyAppleEvent,
  824.     long refCon)
  825. {
  826. #if MPW
  827. #pragma unused(srcAppleEvent,replyAppleEvent,refCon)
  828. #endif
  829.     return errAEEventNotHandled;
  830. }
  831.  
  832.  
  833. pascal OSErr HandleQuit(
  834.     AppleEvent srcAppleEvent,
  835.     AppleEvent replyAppleEvent,
  836.     long refCon)
  837. {
  838. #if MPW
  839. #pragma unused(srcAppleEvent,replyAppleEvent,refCon)
  840. #endif
  841.     gIsRunning = false;
  842.  
  843.     return noErr;
  844. }
  845.  
  846.  
  847. void ErrorAlert(
  848.     OSErr err,
  849.     short errorStringIndex)
  850. {
  851.     Str255 messageString, errorString;
  852.  
  853.         // make sure we don't know what this error is...
  854.     if (errorStringIndex == kUnknownErrorStringIndex)
  855.     {
  856.         switch (err)
  857.         {
  858.             case memFullErr:
  859.                 errorStringIndex = kNotEnoughMemoryStringIndex;
  860.                 break;
  861.  
  862.             case resNotFound:
  863.                 errorStringIndex = kCantFindResourceStringIndex;
  864.                 break;
  865.         }
  866.     }
  867.  
  868.     GetIndString(messageString, kErrorStringListResID, errorStringIndex);
  869.  
  870.     if (messageString[0] == 0)
  871.     {
  872.         BlockMove(kSeriousDamageString, messageString, sizeof(kSeriousDamageString));
  873.     }
  874.  
  875.     NumToString(err, errorString);
  876.  
  877.     ParamText(messageString, errorString, "\p", "\p");
  878.  
  879.     (void)StopAlert(kErrorAlertResID, NULL);
  880. }
  881.  
  882.  
  883. void CantFindResource(void)
  884. {
  885.     OSErr err;
  886.     
  887.     err = ResError();
  888.     
  889.     if (err == noErr)
  890.     {
  891.         err = resNotFound;
  892.     }
  893.  
  894.     ErrorAlert(err, kCantFindResourceStringIndex);
  895.  
  896.     ExitToShell();
  897. }
  898.  
  899.  
  900. void CantRunOnThisMachine(void)
  901. {
  902.     (void)StopAlert(kCantRunAlertResID, NULL);
  903. }
  904.  
  905.  
  906. short NumToolboxTraps(void)
  907. {
  908.     return    (NGetTrapAddress(_InitGraf, ToolTrap) == NGetTrapAddress(0xAA6E, ToolTrap))
  909.                 ?    0x0200 :    0x0400;
  910. }
  911.  
  912.  
  913. TrapType GetTrapType(
  914.     short trap)
  915. {
  916.     #define TrapMask 0x0800
  917.  
  918.     return ((trap & TrapMask) != 0) ? ToolTrap : OSTrap;
  919. }
  920.  
  921.  
  922. Boolean TrapAvail(
  923.     short trap)
  924. {
  925.     TrapType    tType;
  926.  
  927.     tType = GetTrapType(trap);
  928.     if (tType == ToolTrap)
  929.     {
  930.         trap = trap & 0x07FF;
  931.     }
  932.  
  933.     if (trap >= NumToolboxTraps())
  934.     {
  935.         trap = _Unimplemented;
  936.     }
  937.  
  938.     return NGetTrapAddress(trap, tType) !=
  939.              NGetTrapAddress(_Unimplemented, ToolTrap);
  940. }
  941.  
  942.  
  943. Boolean HasWaitNextEvent(void)
  944. {
  945.     return TrapAvail(_WaitNextEvent);
  946. }
  947.  
  948.  
  949.